home *** CD-ROM | disk | FTP | other *** search
/ Libris Britannia 4 / science library(b).zip / science library(b) / TECHNICA / COMPUTER / H254.ZIP / IRITSM3S.ZIP / CAGD_LIB / BZR_READ.C < prev    next >
C/C++ Source or Header  |  1991-09-11  |  11KB  |  326 lines
  1. /******************************************************************************
  2. * Bzr-Read.c - Bezier handling routines - read from file.              *
  3. *******************************************************************************
  4. * Written by Gershon Elber, Mar. 90.                          *
  5. ******************************************************************************/
  6.  
  7. #ifdef __MSDOS__
  8. #include <stdlib.h>
  9. #endif /* __MSDOS__ */
  10.  
  11. #include <ctype.h>
  12. #include <stdio.h>
  13. #include <string.h>
  14. #include "cagd_loc.h"
  15.  
  16. /******************************************************************************
  17. * Reads and returns bezier curve(s) list.                      *
  18. * If error is found in reading the file, ErrStr is set to string describing   *
  19. * it and Line to the line it occured in file.                      *
  20. * If no error is detected *ErrStr = NULL.                      *
  21. ******************************************************************************/
  22. CagdCrvStruct *BzrCrvReadFromFile(char *FileName, char **ErrStr, int *ErrLine)
  23. {
  24.     FILE *f;
  25.     char StringToken[LINE_LEN];
  26.     CagdCrvStruct *Crv,
  27.     *CrvTail = NULL,
  28.     *CrvList = NULL;
  29.  
  30.     if ((f = fopen(FileName, "r")) == NULL) {
  31.     *ErrStr = "File not found";
  32.     *ErrLine = 0;
  33.     return NULL;
  34.     }
  35.  
  36.     while (_CagdGetToken(f, StringToken) == TOKEN_OPEN_PAREN) {
  37.     _CagdUnGetToken(StringToken);
  38.         Crv = BzrCrvReadFromFile2(f, FALSE, ErrStr, ErrLine);
  39.  
  40.     if (CrvList == NULL)
  41.         CrvList = CrvTail = Crv;
  42.     else {
  43.         CrvTail -> Pnext = Crv;
  44.         CrvTail = Crv;
  45.     }
  46.     }
  47.  
  48.     fclose(f);
  49.  
  50.     return CrvList;
  51. }
  52.  
  53. /******************************************************************************
  54. * Reads and returns a bezier curve.                          *
  55. * If NameWasRead is TRUE, it is assumed prefix "[CURVE BEZIER" has already    *
  56. * been read. This is useful for a global parser which invokes this routine.   *
  57. * For exactly this reason, the file is NOT closed in the end.              *
  58. * If error is found in reading the file, ErrStr is set to string describing   *
  59. * it and ErrLine to line it occured in file relative to begining of curve.    *
  60. * If no error is detected *ErrStr is set to NULL.                  *
  61. ******************************************************************************/
  62. CagdCrvStruct *BzrCrvReadFromFile2(FILE *f, CagdBType NameWasRead,
  63.                         char **ErrStr, int *ErrLine)
  64. {
  65.     CagdPointType PType;
  66.     TokenNumType Token;
  67.     int i, j, Length, MaxCoord;
  68.     char StringToken[LINE_LEN];
  69.     CagdCrvStruct *NewCrv;
  70.  
  71.     _CagdGlblLineCount = *ErrLine;
  72.  
  73.     if (!NameWasRead) {
  74.     while ((Token = _CagdGetToken(f, StringToken)) != TOKEN_EOF &&
  75.            Token != TOKEN_OPEN_PAREN);
  76.  
  77.     /* We found beginning of definition - read one: */
  78.     if (_CagdGetToken(f, StringToken) != TOKEN_CURVE ||
  79.         _CagdGetToken(f, StringToken) != TOKEN_BEZIER) {
  80.             *ErrStr = "CURVE BEZIER key words expected";
  81.         *ErrLine = _CagdGlblLineCount;
  82.         return NULL;
  83.     }
  84.     }
  85.  
  86.     if ((Token = _CagdGetToken(f, StringToken)) == TOKEN_OPEN_PAREN) {
  87.     if ((*ErrStr = _CagdGetCurveAttributes(f)) != NULL) {
  88.             *ErrStr = "\"[\" expected";
  89.         *ErrLine = _CagdGlblLineCount;
  90.         return NULL;
  91.     }
  92.     }
  93.     else
  94.     _CagdUnGetToken(StringToken);
  95.  
  96.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  97.     sscanf(StringToken, "%d", &Length) != 1) {
  98.     *ErrStr = "BEZIER Number of points expected";
  99.     *ErrLine = _CagdGlblLineCount;
  100.     return NULL;
  101.     }
  102.  
  103.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  104.     strlen(StringToken) != 2 ||
  105.     (StringToken[0] != 'E' && StringToken[0] != 'P') ||
  106.     !isdigit(StringToken[1]) ||
  107.     atoi(&StringToken[1]) >= CAGD_MAX_PT_COORD) {
  108.     *ErrStr = "BEZIER Point type expected";
  109.     *ErrLine = _CagdGlblLineCount;
  110.     return NULL;
  111.     }
  112.  
  113.     PType = CAGD_MAKE_PT_TYPE(StringToken[0] == 'P', atoi(&StringToken[1]));
  114.  
  115.     NewCrv = BzrCrvNew(Length, PType);
  116.  
  117.     /* Read the points themselves: */
  118.     MaxCoord = CAGD_NUM_OF_PT_COORD(PType);
  119.     for (i = 0; i < Length; i++) {
  120.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OPEN_PAREN) {
  121.         *ErrStr = "\"[\" expected";
  122.         *ErrLine = _CagdGlblLineCount;
  123.         CagdCrvFree(NewCrv);
  124.         return NULL;
  125.     }
  126.     if (CAGD_IS_RATIONAL_PT(PType)) {
  127.         if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  128. #ifdef CAGD_DOUBLE
  129.         sscanf(StringToken, "%lf", &NewCrv -> Points[W][i]) != 1) {
  130. #else
  131.             sscanf(StringToken, "%f", &NewCrv -> Points[W][i]) != 1) {
  132. #endif /* CAGD_DOUBLE */
  133.         *ErrStr = "Numeric data expected";
  134.         *ErrLine = _CagdGlblLineCount;
  135.         CagdCrvFree(NewCrv);
  136.         return NULL;
  137.         }
  138.     }
  139.     for (j = 1; j <= MaxCoord; j++) {
  140.         if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  141. #ifdef CAGD_DOUBLE
  142.         sscanf(StringToken, "%lf", &NewCrv -> Points[j][i]) != 1) {
  143. #else
  144.             sscanf(StringToken, "%f", &NewCrv -> Points[j][i]) != 1) {
  145. #endif /* CAGD_DOUBLE */
  146.         *ErrStr = "Numeric data expected";
  147.         *ErrLine = _CagdGlblLineCount;
  148.         CagdCrvFree(NewCrv);
  149.         return NULL;
  150.         }
  151.     }
  152.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_CLOSE_PAREN) {
  153.         *ErrStr = "\"]\" expected";
  154.         *ErrLine = _CagdGlblLineCount;
  155.         CagdCrvFree(NewCrv);
  156.         return NULL;
  157.     }
  158.     }
  159.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_CLOSE_PAREN) {
  160.     *ErrStr = "\"]\" expected";
  161.     *ErrLine = _CagdGlblLineCount;
  162.     CagdCrvFree(NewCrv);
  163.     return NULL;
  164.     }
  165.  
  166.     *ErrLine = _CagdGlblLineCount;
  167.     *ErrStr = NULL;
  168.  
  169.     return NewCrv;
  170. }
  171.  
  172. /******************************************************************************
  173. * Reads and returns a bezier surface.                          *
  174. * If error is found in reading the file, ErrStr is set to string describing   *
  175. * it and ErrLine to the line it occured in file.                  *
  176. * If no error is detected *ErrStr = NULL.                      *
  177. ******************************************************************************/
  178. CagdSrfStruct *BzrSrfReadFromFile(char *FileName, char **ErrStr, int *ErrLine)
  179. {
  180.     FILE *f;
  181.     char StringToken[LINE_LEN];
  182.     CagdSrfStruct *Srf,
  183.     *SrfTail = NULL,
  184.     *SrfList = NULL;
  185.  
  186.     if ((f = fopen(FileName, "r")) == NULL) {
  187.     *ErrStr = "File not found";
  188.     return NULL;
  189.     }
  190.  
  191.     while (_CagdGetToken(f, StringToken) == TOKEN_OPEN_PAREN) {
  192.     _CagdUnGetToken(StringToken);
  193.         Srf = BzrSrfReadFromFile2(f, FALSE, ErrStr, ErrLine);
  194.  
  195.     if (SrfList == NULL)
  196.         SrfList = SrfTail = Srf;
  197.     else {
  198.         SrfTail -> Pnext = Srf;
  199.         SrfTail = Srf;
  200.     }
  201.     }
  202.  
  203.     fclose(f);
  204.  
  205.     return SrfList;
  206. }
  207.  
  208. /******************************************************************************
  209. * Reads and returns a bezier surface.                          *
  210. * If NameWasRead is TRUE, it is assumed prefix "[SURFACE BEZIER" has already  *
  211. * been read. This is useful for a global parser which invokes this routine.   *
  212. * For exactly this reason, the file is NOT closed in the end.              *
  213. * If error is found in reading the file, ErrStr is set to string describing   *
  214. * it and ErrLine to the line it occured in file.                    *
  215. * If no error is detected *ErrStr = NULL.                      *
  216. ******************************************************************************/
  217. CagdSrfStruct *BzrSrfReadFromFile2(FILE *f, CagdBType NameWasRead,
  218.                         char **ErrStr, int *ErrLine)
  219. {
  220.     CagdPointType PType;
  221.     TokenNumType Token;
  222.     int i, j, ULength, VLength, MaxCoord;
  223.     char StringToken[LINE_LEN];
  224.     CagdSrfStruct *NewSrf;
  225.  
  226.     _CagdGlblLineCount = *ErrLine;
  227.  
  228.     if (!NameWasRead) {
  229.     while ((Token = _CagdGetToken(f, StringToken)) != TOKEN_EOF &&
  230.            Token != TOKEN_OPEN_PAREN);
  231.  
  232.     /* We found beginning of definition - read one: */
  233.     if (_CagdGetToken(f, StringToken) != TOKEN_SURFACE ||
  234.         _CagdGetToken(f, StringToken) != TOKEN_BEZIER) {
  235.         *ErrStr = "SURFACE BEZIER key words expected";
  236.         *ErrLine = _CagdGlblLineCount;
  237.         return NULL;
  238.         }
  239.     }
  240.  
  241.     if ((Token = _CagdGetToken(f, StringToken)) == TOKEN_OPEN_PAREN) {
  242.     if ((*ErrStr = _CagdGetSurfaceAttributes(f)) != NULL) {
  243.         *ErrStr = "\"[\" expected";
  244.         *ErrLine = _CagdGlblLineCount;
  245.         return NULL;
  246.     }
  247.     }
  248.     else
  249.     _CagdUnGetToken(StringToken);
  250.  
  251.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  252.         sscanf(StringToken, "%d", &ULength) != 1 ||
  253.     (Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  254.     sscanf(StringToken, "%d", &VLength) != 1) {
  255.     *ErrStr = "BEZIER Number of points expected";
  256.     *ErrLine = _CagdGlblLineCount;
  257.     return NULL;
  258.     }
  259.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  260.         strlen(StringToken) != 2 ||
  261.     (StringToken[0] != 'E' && StringToken[0] != 'P') ||
  262.     !isdigit(StringToken[1]) ||
  263.     atoi(&StringToken[1]) >= CAGD_MAX_PT_COORD) {
  264.     *ErrStr = "BEZIER Point type expected";
  265.     *ErrLine = _CagdGlblLineCount;
  266.     return NULL;
  267.     }
  268.     PType = CAGD_MAKE_PT_TYPE(StringToken[0] == 'P', atoi(&StringToken[1]));
  269.  
  270.     NewSrf = BzrSrfNew(ULength, VLength, PType);
  271.  
  272.     /* Read the points themselves: */
  273.     MaxCoord = CAGD_NUM_OF_PT_COORD(PType);
  274.     for (i = 0; i < ULength * VLength; i++) {
  275.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OPEN_PAREN) {
  276.         *ErrStr = "\"[\" expected";
  277.         *ErrLine = _CagdGlblLineCount;
  278.         CagdSrfFree(NewSrf);
  279.         return NULL;
  280.     }
  281.     if (CAGD_IS_RATIONAL_PT(PType)) {
  282.         if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  283. #ifdef CAGD_DOUBLE
  284.             sscanf(StringToken, "%lf", &NewSrf -> Points[W][i]) != 1) {
  285. #else
  286.             sscanf(StringToken, "%f", &NewSrf -> Points[W][i]) != 1) {
  287. #endif /* CAGD_DOUBLE */
  288.         *ErrStr = "Numeric data expected";
  289.         *ErrLine = _CagdGlblLineCount;
  290.         CagdSrfFree(NewSrf);
  291.         return NULL;
  292.         }
  293.     }
  294.     for (j = 1; j <= MaxCoord; j++) {
  295.         if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_OTHER ||
  296. #ifdef CAGD_DOUBLE
  297.             sscanf(StringToken, "%lf", &NewSrf -> Points[j][i]) != 1) {
  298. #else
  299.             sscanf(StringToken, "%f", &NewSrf -> Points[j][i]) != 1) {
  300. #endif /* CAGD_DOUBLE */
  301.         *ErrStr = "Numeric data expected";
  302.         *ErrLine = _CagdGlblLineCount;
  303.         CagdSrfFree(NewSrf);
  304.         return NULL;
  305.         }
  306.     }
  307.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_CLOSE_PAREN) {
  308.         *ErrStr = "\"]\" expected";
  309.         *ErrLine = _CagdGlblLineCount;
  310.         CagdSrfFree(NewSrf);
  311.         return NULL;
  312.     }
  313.     }
  314.     if ((Token = _CagdGetToken(f, StringToken)) != TOKEN_CLOSE_PAREN) {
  315.         *ErrStr = "\"]\" expected";
  316.     *ErrLine = _CagdGlblLineCount;
  317.     CagdSrfFree(NewSrf);
  318.     return NULL;
  319.     }
  320.  
  321.     *ErrStr = NULL;
  322.     *ErrLine = _CagdGlblLineCount;
  323.  
  324.     return NewSrf;
  325. }
  326.